home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / SNNSV32.ZIP / SNNSv3.2 / kernel / sources / dlvq_learn.c < prev    next >
C/C++ Source or Header  |  1994-04-25  |  29KB  |  1,104 lines
  1. /*****************************************************************************
  2.   FILE           : dlvq_learn.c
  3.   SHORTNAME      : 
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : Functions of DLVQ
  7.   NOTES          :
  8.  
  9.   AUTHOR         : Michael Schmalzl 
  10.   DATE           : 5.2.93
  11.  
  12.   CHANGED BY     : Michael Vogt, Guenter Mamier
  13.   IDENTIFICATION : @(#)dlvq_learn.c    1.9 4/6/94
  14.   SCCS VERSION   : 1.9
  15.   LAST CHANGE    : 4/6/94
  16.  
  17.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  18.  
  19. ******************************************************************************/
  20.  
  21. #include <stdio.h>
  22. #include <math.h>
  23. #include <time.h>  
  24. #include <memory.h>
  25. #include <malloc.h>
  26. #include <values.h>
  27.  
  28. #include "kr_typ.h"      /*  Kernel Types and Constants  */
  29. #include "kr_const.h"    /*  Constant Declarators for SNNS-Kernel  */
  30. #include "kr_def.h"      /*  Default Values  */
  31. #include "kernel.h"      /*  kernel function prototypes  */
  32. #include "kr_ui.h"
  33. #include "kr_mac.h"      /*  Kernel Macros   */
  34.  
  35. #include "kr_ui.h"
  36. #include "cc_mac.h"
  37. #include "kr_newpattern.h"
  38. #include "cc_rcc.h"
  39. #include "dlvq_type.h"
  40. #include "dlvq_learn.ph"
  41.  
  42.  
  43. /*****************************************************************************
  44.   FUNCTION : sortHiddenUnitsByClasses
  45.  
  46.   PURPOSE  : Sorts the hidden units by its class.
  47.   NOTES    :
  48.  
  49.   UPDATE   : 5.2.93
  50. ******************************************************************************/
  51. static void sortHiddenUnitsByClasses(int left, int right)
  52. {
  53.     int i,last;
  54.     struct Unit *temp;
  55.  
  56.     if(left >= right ){
  57.     return;
  58.     }
  59.     temp = FirstHiddenUnitPtr[left]; 
  60.     FirstHiddenUnitPtr[left] = FirstHiddenUnitPtr[(left+right)/2]; 
  61.     FirstHiddenUnitPtr[(left+right)/2] = temp;  
  62.     last = left; 
  63.     for(i=left+1;i<=right;i++){
  64.     if(FirstHiddenUnitPtr[i]->bias < FirstHiddenUnitPtr[left]->bias) {
  65.         temp = FirstHiddenUnitPtr[++last]; 
  66.         FirstHiddenUnitPtr[last]=FirstHiddenUnitPtr[i]; 
  67.         FirstHiddenUnitPtr[i]=temp;
  68.     }
  69.     }
  70.     temp = FirstHiddenUnitPtr[left]; 
  71.     FirstHiddenUnitPtr[left]=FirstHiddenUnitPtr[last]; 
  72.     FirstHiddenUnitPtr[last] = temp;
  73.     sortHiddenUnitsByClasses(left,last);
  74.     sortHiddenUnitsByClasses(last+1,right);
  75. }
  76.  
  77.  
  78.  
  79. /*****************************************************************************
  80.   FUNCTION : getNoOfClasses
  81.  
  82.   PURPOSE  : Looks how many different classes exist and checks whether the 
  83.              no. of the first class is zero.
  84.   NOTES    :
  85.  
  86.   UPDATE   : 5.2.93
  87. ******************************************************************************/
  88. krui_err getNoOfClasses(int startPattern, int endPattern)
  89. {
  90.     int p,patternClass=0,maxPatternClass=0,minPatternClass=0;
  91.     int *tmpArray,counter,class;
  92.     int start, end;
  93.     int pat, sub_pat;
  94.     Patterns out_pat;
  95.  
  96.     KernelErrorCode = kr_initSubPatternOrder(startPattern, endPattern);
  97.     if (KernelErrorCode != KRERR_NO_ERROR)
  98.     return KernelErrorCode;
  99.     start = kr_AbsPosOfFirstSubPat(startPattern);
  100.     end   = kr_AbsPosOfFirstSubPat(endPattern);
  101.     end  += kr_NoOfSubPatPairs(endPattern) - 1;
  102.     for(p=start; p<=end;p++){
  103.  
  104.     kr_getSubPatternByNo(&pat, &sub_pat, p);
  105.     out_pat = kr_getSubPatData(pat, sub_pat, OUTPUT, NULL);
  106.  
  107.     patternClass = *out_pat;
  108.     if(patternClass < minPatternClass){
  109.         minPatternClass = patternClass;
  110.     } 
  111.     if(patternClass > maxPatternClass){
  112.         maxPatternClass = patternClass;
  113.     } 
  114.     }
  115.  
  116.     if(minPatternClass != 0){
  117.     return(DLVQ_ERROR2); /* There exists a class smaller than 0 */
  118.     } 
  119.  
  120.     counter = 0;
  121.     p = start;
  122.     tmpArray =  (int *)calloc(maxPatternClass+1,sizeof(int));
  123.  
  124.     while((counter != (maxPatternClass+1)) && (p <= end)){
  125.     kr_getSubPatternByNo(&pat, &sub_pat, p++);
  126.     out_pat = kr_getSubPatData(pat, sub_pat, OUTPUT, NULL);
  127.     class = *out_pat;
  128.     if(tmpArray[class] == 0){
  129.         counter++;
  130.         tmpArray[class] = 1;
  131.     }
  132.     }
  133.     free(tmpArray);
  134.     
  135.     if(counter != (maxPatternClass+1)){
  136.     return(DLVQ_ERROR1); /*  There are empty classes */
  137.     }
  138.     noOfClasses = maxPatternClass+1;
  139.     return(KRERR_NO_ERROR);
  140. }
  141.  
  142.  
  143.  
  144. /*****************************************************************************
  145.   FUNCTION : allocMixupArray
  146.  
  147.   PURPOSE  : Allocate the storage of the "mixupArray".
  148.   NOTES    :
  149.  
  150.   UPDATE   : 5.2.93
  151. ******************************************************************************/
  152. static void allocMixupArray(void)
  153. {
  154.     int i,j;
  155.  
  156.     /* free storage */
  157.     for(i=0;i<oldNoOfClasses;i++) {
  158.     for(j=0;j<oldNoOfClasses;j++) {
  159.         free(mixupArray[i][j].link);
  160.     }
  161.     }
  162.  
  163.     for(i=0;i<oldNoOfClasses;i++) {
  164.     free(mixupArray[i]);
  165.     }
  166.  
  167.     if(mixupArray != NULL) {
  168.     free(mixupArray);
  169.     mixupArray = NULL;
  170.     }
  171.  
  172.     /* alloc storage */
  173.     mixupArray = (struct MIX_UP **)calloc(noOfClasses,sizeof(struct MIX_UP *));
  174.  
  175.     for(i=0;i<noOfClasses;i++) {
  176.     mixupArray[i] = 
  177.         (struct MIX_UP *)calloc(noOfClasses,sizeof(struct MIX_UP));   
  178.     }
  179.  
  180.     for(i=0;i<noOfClasses;i++) {
  181.     for(j=0;j<noOfClasses;j++) {
  182.         mixupArray[i][j].link = 
  183.               (double *)calloc(NoOfInputUnits,sizeof(double));
  184.     }
  185.     }
  186. }
  187.  
  188.  
  189.  
  190. /*****************************************************************************
  191.   FUNCTION : allocLastInsertedUnitArray
  192.  
  193.   PURPOSE  : Allocate the storage of the array "lastInsertedUnitArray".
  194.   NOTES    :
  195.  
  196.   UPDATE   : 5.2.93
  197. ******************************************************************************/
  198. static void allocLastInsertedUnitArray(void)
  199. {
  200.  
  201.     /* free storage */
  202.     if(lastInsertedUnitArray != NULL){
  203.     free(lastInsertedUnitArray);
  204.     lastInsertedUnitArray = NULL;
  205.     }
  206.  
  207.     /* alloc storage */
  208.     lastInsertedUnitArray = (int *)calloc(noOfClasses,sizeof(int));
  209. }
  210.  
  211.  
  212.  
  213. /*****************************************************************************
  214.   FUNCTION : allocInitialUnitArray
  215.  
  216.   PURPOSE  : Allocate the storage of the array "initialUnitArray"
  217.   NOTES    :
  218.  
  219.   UPDATE   : 5.2.93
  220. ******************************************************************************/
  221. void allocInitialUnitArray(void)
  222. {
  223.     int i;
  224.  
  225.     /* free storage */
  226.     for(i=0;i<oldNoOfClasses;i++) {
  227.     free(initialUnitArray[i].link);
  228.     }
  229.  
  230.     if(initialUnitArray != NULL) {
  231.     free(initialUnitArray);
  232.     initialUnitArray = NULL;
  233.     }
  234.  
  235.     /* alloc storage */
  236.     initialUnitArray = 
  237.     (struct MIX_UP *)calloc(noOfClasses,sizeof(struct MIX_UP));
  238.  
  239.     for(i=0;i<noOfClasses;i++) {
  240.     initialUnitArray[i].link = 
  241.         (double *)calloc(NoOfInputUnits,sizeof(double));
  242.     }
  243. }
  244.  
  245.  
  246.  
  247. /*****************************************************************************
  248.   FUNCTION : normPatterns
  249.  
  250.   PURPOSE  : Norm all patterns.
  251.   NOTES    : This function is of no permanent effect since the manipulation 
  252.   of  the input pattern takes place on a copy of the original data.
  253.   Patterns must be normalized before use of DLVQ !!!!!
  254.   Therefore the body of the function is commented out. The original code is 
  255.   left in place to demonstrate the necessary operation. (M. Vogt)
  256.  
  257.   UPDATE   : 5.2.93
  258. ******************************************************************************/
  259. void normPatterns(int startPattern, int endPattern)
  260. {
  261.  
  262. /* see NOTES of funtion header */
  263.  
  264. /*
  265.     double sum,sqrtSum;
  266.     Patterns in_pat,in_patStorage;
  267.     int p,i;
  268.     int start, end;
  269.     int pat, sub;
  270.     int count;
  271.  
  272.     KernelErrorCode = kr_initSubPatternOrder(startPattern,endPattern);
  273.     start = kr_AbsPosOfFirstSubPat(startPattern);
  274.     end   = kr_AbsPosOfFirstSubPat(endPattern);
  275.     end  += kr_NoOfSubPatPairs(endPattern) - 1;
  276.     for(p=start; p<=end;p++){
  277.  
  278.     kr_getSubPatternByNo(&pat,&sub,p);
  279.     in_pat = kr_getSubPatData(pat,sub,INPUT,&count);
  280.     sum = 0.0;  
  281.     in_patStorage = in_pat;  
  282.  
  283.     for(i=0;i<count;i++){   
  284.         sum += (*in_pat) * (*in_pat);
  285.         in_pat++;
  286.     }
  287.     sqrtSum = sqrt(sum);
  288.     in_pat = in_patStorage;
  289.  
  290.     for(i=0;i<count;i++){   
  291.         *in_pat = *in_pat / sqrtSum;
  292.         in_pat++;
  293.     }
  294.     }
  295. */
  296. }
  297.  
  298.  
  299.  
  300. /*****************************************************************************
  301.   FUNCTION : normReferenceVec
  302.  
  303.   PURPOSE  :
  304.   NOTES    :
  305.  
  306.   UPDATE   : 5.2.93
  307. ******************************************************************************/
  308. static void normReferenceVec(struct Unit *hiddenUnitPtr)
  309. {
  310.     double sum,sqrtSum;
  311.     struct Link *linkPtr;
  312.  
  313.     sum = 0.0;
  314.     FOR_ALL_LINKS(hiddenUnitPtr,linkPtr) {
  315.     sum += linkPtr->weight * linkPtr->weight;
  316.     }
  317.  
  318.     sqrtSum = sqrt(sum);
  319.  
  320.     FOR_ALL_LINKS(hiddenUnitPtr,linkPtr){
  321.     linkPtr->weight = linkPtr->weight / sqrtSum;
  322.     }
  323. }
  324.  
  325.  
  326.  
  327. /*****************************************************************************
  328.   FUNCTION : moveVec
  329.  
  330.   PURPOSE  : Train the vectors.
  331.   NOTES    :
  332.  
  333.   UPDATE   : 5.2.93
  334. ******************************************************************************/
  335. static void moveVec(struct Unit *correctReferenceVec, float learnParam1,
  336.                     struct Unit *wrongReferenceVec,   float learnParam2)
  337. {
  338.     struct Link *linkPtr;
  339.  
  340.     FOR_ALL_LINKS(correctReferenceVec,linkPtr){
  341.     linkPtr->weight += learnParam1 * (linkPtr->to->act - linkPtr->weight);
  342.     }
  343.     normReferenceVec(correctReferenceVec);
  344.  
  345.     FOR_ALL_LINKS(wrongReferenceVec,linkPtr){
  346.     linkPtr->weight -= learnParam2 * (linkPtr->to->act - linkPtr->weight);
  347.     }
  348.     normReferenceVec(wrongReferenceVec);
  349. }
  350.  
  351.  
  352.  
  353. /*****************************************************************************
  354.   FUNCTION : 
  355.  
  356.   PURPOSE  :
  357.   NOTES    :
  358.  
  359.   UPDATE   : 5.2.93
  360. ******************************************************************************/
  361. static void writeVectorToMixupArray(int correctClass, int wrongClass, 
  362.                     int patternNo, int sub_pat_no)
  363. {
  364.     Patterns in_pat;
  365.     double *link=NULL;
  366.     int i,count;
  367.  
  368.     /* calculate startaddress for input pattern array  */
  369.     in_pat = kr_getSubPatData(patternNo,sub_pat_no,INPUT,&count);
  370.     link = mixupArray[correctClass][wrongClass].link; 
  371.  
  372.     for(i=0;i<count;i++){
  373.     link[i] = (double)in_pat[i];
  374.     }
  375. }
  376.  
  377.  
  378.  
  379. /*****************************************************************************
  380.   FUNCTION : initInitialUnitArray
  381.  
  382.   PURPOSE  : Init the array "initialUnitArray".
  383.   NOTES    :
  384.  
  385.   UPDATE   : 5.2.93
  386. ******************************************************************************/
  387. void initInitialUnitArray(int startPattern, int endPattern)
  388. {
  389.     int p,i,j;
  390.     Patterns in_pat;
  391.     Patterns out_pat;
  392.     int start, end;
  393.     int pat, sub;
  394.     int count;
  395.  
  396.     KernelErrorCode = kr_initSubPatternOrder(startPattern,endPattern);
  397.     start = kr_AbsPosOfFirstSubPat(startPattern);
  398.     end   = kr_AbsPosOfFirstSubPat(endPattern);
  399.     end  += kr_NoOfSubPatPairs(endPattern) - 1;
  400.     for(p=start; p<=end;p++){
  401.     kr_getSubPatternByNo(&pat,&sub,p);
  402.     in_pat = kr_getSubPatData(pat,sub,INPUT,&count);
  403.     out_pat = kr_getSubPatData(pat,sub,OUTPUT,NULL);
  404.     for(i=0;i<count;i++){
  405.         (initialUnitArray[(int) *out_pat].link)[i] = *in_pat++;
  406.         initialUnitArray[(int) *out_pat].counter++;
  407.     }
  408.     }
  409.     for(i=0;i<noOfClasses;i++){
  410.     for(j=0;j<count;j++){
  411.         (initialUnitArray[i].link)[j] /= initialUnitArray[i].counter;
  412.     }
  413.     }
  414. }
  415.  
  416.  
  417.  
  418. /*****************************************************************************
  419.   FUNCTION : initFirstUnit
  420.  
  421.   PURPOSE  : Init the links of a class unit. Remember: At the beginning of
  422.              the learning there exist no hidden units. The first step of 
  423.              the algorithm inserts for every class a hidden unit. This
  424.              functions inits the links of this first units. The array
  425.              "initialUnitArray" contains for every class the average
  426.              activation over all patterns.
  427.   NOTES    :
  428.  
  429.   UPDATE   : 5.2.93
  430. ******************************************************************************/
  431. static void initFirstUnit(struct Unit *hiddenUnitPtr, int class)
  432. {
  433.     int i;
  434.     struct Link *linkPtr;
  435.     struct Unit *inputUnitPtr;
  436.  
  437.     i = 0;
  438.     FOR_ALL_UNITS(inputUnitPtr){
  439.     if(IS_INPUT_UNIT(inputUnitPtr) && UNIT_IN_USE(inputUnitPtr)){
  440.         inputUnitPtr->act = (initialUnitArray[class].link)[i++];
  441.     }
  442.     }
  443.  
  444.     hiddenUnitPtr->bias = class;
  445.     FOR_ALL_LINKS(hiddenUnitPtr,linkPtr) {
  446.     linkPtr->weight = linkPtr->to->act;
  447.     }
  448.     normReferenceVec(hiddenUnitPtr);
  449. }
  450.  
  451.  
  452.  
  453. /*****************************************************************************
  454.   FUNCTION : deleteAllLinksOfTheOutputUnit
  455.  
  456.   PURPOSE  : 
  457.   NOTES    :
  458.  
  459.   UPDATE   : 5.2.93
  460. ******************************************************************************/
  461. static krui_err deleteAllLinksOfTheOutputUnit(void)
  462. {
  463.     KernelErrorCode = krui_setCurrentUnit(GET_UNIT_NO(*FirstOutputUnitPtr));
  464.     ERROR_CHECK;
  465.  
  466.     krui_deleteAllInputLinks();
  467.     krui_deleteAllOutputLinks();
  468.  
  469.     return(KRERR_NO_ERROR);
  470. }
  471.  
  472.  
  473.  
  474. /*****************************************************************************
  475.   FUNCTION : calculateUnitXYPos
  476.  
  477.   PURPOSE  : Calculates the position of the current input, hidden and output
  478.              layer.
  479.   NOTES    :
  480.  
  481.   UPDATE   : 5.2.93
  482. ******************************************************************************/
  483. static void calculateUnitXYPos(void)
  484. {
  485.     int xPos,yPos,maxXPos=0,maxYPos,minXPos=0,minYPos=0,i,
  486.         xOffset,yOffset,bias,h;
  487.     struct Unit *inputUnitPtr=NULL,*hiddenUnitPtr;
  488.  
  489.     inputUnitPtr = *FirstInputUnitPtr;
  490.     maxXPos = minXPos = GET_UNIT_XPOS(inputUnitPtr);
  491.     maxYPos = minYPos = GET_UNIT_YPOS(inputUnitPtr); 
  492.  
  493.     /* find maxXPos ... of the input layer */
  494.     FOR_ALL_INPUT_UNITS(inputUnitPtr,i) {
  495.     xPos = GET_UNIT_XPOS(inputUnitPtr);
  496.     yPos = GET_UNIT_YPOS(inputUnitPtr);
  497.     if(xPos > maxXPos) {
  498.         maxXPos = xPos;
  499.     }
  500.     if(xPos < minXPos){
  501.         minXPos = xPos;
  502.     }
  503.     if(yPos > maxYPos) {
  504.         maxYPos = yPos;
  505.     }
  506.     if(yPos < minYPos){
  507.         minYPos = yPos;
  508.     }
  509.     }
  510.  
  511.     xOffset = minXPos - 2;
  512.     yOffset = minYPos - 2;
  513.  
  514.     FOR_ALL_INPUT_UNITS(inputUnitPtr,i){
  515.     SET_UNIT_XPOS(inputUnitPtr,GET_UNIT_XPOS(inputUnitPtr) - xOffset);
  516.     SET_UNIT_YPOS(inputUnitPtr,GET_UNIT_YPOS(inputUnitPtr) - yOffset);
  517.     }
  518.  
  519.     bias = (*FirstHiddenUnitPtr)->bias; 
  520.     xPos = (maxXPos - xOffset + 3);
  521.     yPos = 1;
  522.  
  523.     FOR_ALL_HIDDEN_UNITS(hiddenUnitPtr,h){
  524.     if(bias == hiddenUnitPtr->bias){
  525.         yPos++;
  526.     }else{
  527.         xPos++;
  528.         bias = hiddenUnitPtr->bias;
  529.         yPos = 2;
  530.     }
  531.     SET_UNIT_XPOS(hiddenUnitPtr,xPos);
  532.     SET_UNIT_YPOS(hiddenUnitPtr,yPos);
  533.     }   
  534.  
  535.     SET_UNIT_XPOS(*FirstOutputUnitPtr,xPos+3);
  536.     SET_UNIT_YPOS(*FirstOutputUnitPtr,2);
  537. }
  538.  
  539.  
  540.  
  541. /*****************************************************************************
  542.   FUNCTION : insertNewUnits
  543.  
  544.   PURPOSE  : Inserts new hidden units to the net. The weights of the links
  545.              are stored in the "mixupArray". 
  546.   NOTES    :
  547.  
  548.   UPDATE   : 5.2.93
  549. ******************************************************************************/
  550. static krui_err insertNewUnits(void)
  551. {
  552.     int i,j,k,maxCount,maxJ=0,newUnit;
  553.     double sum,sqrtSum,weight;
  554.     struct Unit *newUnitPtr,*inputUnitPtr;
  555.     struct Link *linkPtr;
  556.  
  557.     for(i=0;i<noOfClasses;i++) {
  558.     maxCount = 0;
  559.     for(j=0;j<noOfClasses;j++){
  560.         if(mixupArray[i][j].counter > maxCount) {
  561.         maxCount = mixupArray[i][j].counter;
  562.         maxJ = j;
  563.         }     
  564.     }
  565.     if(maxCount != 0){
  566.  
  567.         /* Generate new unit */
  568.         newUnit = 
  569.         KernelErrorCode = 
  570.             krui_copyUnit(lastInsertedUnitArray[i],INPUTS_AND_OUTPUTS);
  571.         if(KernelErrorCode < 0){
  572.         ERROR_CHECK;
  573.         }
  574.         KernelErrorCode = KRERR_NO_ERROR; 
  575.         newUnitPtr = kr_getUnitPtr(lastInsertedUnitArray[i] = newUnit);
  576.         newUnitPtr->unit_pos.y += 1;     
  577.    
  578.         /*init new unit */
  579.         sum = 0.0;
  580.         k = 0;
  581.         FOR_ALL_UNITS(inputUnitPtr){
  582.         if(IS_INPUT_UNIT(inputUnitPtr) && UNIT_IN_USE(inputUnitPtr)) {
  583.             weight = 
  584.             inputUnitPtr->act = 
  585.                 ((mixupArray[i][maxJ].link)[k++] /
  586.                  mixupArray[i][maxJ].counter);     
  587.             sum += weight * weight;
  588.         }
  589.         }
  590.         sqrtSum = sqrt(sum);
  591.  
  592.         FOR_ALL_LINKS(newUnitPtr,linkPtr) {
  593.         linkPtr->weight = linkPtr->to->act / sqrtSum;
  594.         }
  595.     }
  596.     }
  597.  
  598.     initMixupArray();
  599.  
  600.     return(KRERR_NO_ERROR);
  601. } 
  602.  
  603.  
  604.  
  605. /*****************************************************************************
  606.   FUNCTION : initMixupArray
  607.  
  608.   PURPOSE  : Init the array "mixupArray".
  609.   NOTES    :
  610.  
  611.   UPDATE   : 5.2.93
  612. ******************************************************************************/
  613. static void initMixupArray(void)
  614. {
  615.     int i,j,sizeOfInputVector;
  616.     
  617.     sizeOfInputVector = sizeof(double) * NoOfInputUnits;
  618.  
  619.     for(i=0;i<noOfClasses;i++) {
  620.     for(j=0;j<noOfClasses;j++){
  621.         if(mixupArray[i][j].counter != 0){
  622.         (void)memset(mixupArray[i][j].link,0,sizeOfInputVector);
  623.         mixupArray[i][j].counter = 0;
  624.         }
  625.     }
  626.     }
  627. }
  628.  
  629.  
  630.  
  631. /*****************************************************************************
  632.   FUNCTION :  printMixupArray
  633.  
  634.   PURPOSE  :
  635.   NOTES    :
  636.  
  637.   UPDATE   : 5.2.93
  638. ******************************************************************************/
  639. static void printMixupArray(int cycle)
  640. {
  641.     int i,j;
  642.  
  643.     printf("Cycle %d \n",cycle+1);
  644.     printf("Total number of incorrectly classified items: %d \n",
  645.        wrongClassCounter);
  646.     printf("Array of classified items:\n\n");
  647.  
  648.     for(i=0;i<noOfClasses;i++) {
  649.     for(j=0;j<noOfClasses;j++){
  650.         printf("%d ",mixupArray[i][j].counter);
  651.     }
  652.     printf("\n");
  653.     }
  654.     printf("\n\n");
  655. }
  656.  
  657.  
  658.  
  659. /*****************************************************************************
  660.   FUNCTION : dlvq_trainNet
  661.  
  662.   PURPOSE  :
  663.   NOTES    :
  664.  
  665.   UPDATE   : 5.2.93
  666. ******************************************************************************/
  667. static void dlvq_trainNet(int noOfTrainingCycles, int startPattern,
  668.               int endPattern, float learnParam1, float learnParam2)
  669. {
  670.     struct Unit *correctMaxActivatedUnitPtr=NULL,
  671.     *wrongMaxActivatedUnitPtr=NULL,
  672.     *inputUnitPtr,
  673.     *hiddenUnitPtr;
  674.     double correctMaxAct,wrongMaxAct,act;
  675.     Patterns in_pat;
  676.     Patterns out_pat;
  677.     int i,h,p,j,noOfTrainingCyclesMinus1=noOfTrainingCycles-1;
  678.     struct Link *linkPtr;
  679.     int start, end;
  680.     int pat, sub;
  681.  
  682.     for(j=0;j<noOfTrainingCycles;j++){
  683.  
  684.     KernelErrorCode = kr_initSubPatternOrder(startPattern,endPattern);
  685.     start = kr_AbsPosOfFirstSubPat(startPattern);
  686.     end   = kr_AbsPosOfFirstSubPat(endPattern);
  687.     end  += kr_NoOfSubPatPairs(endPattern) - 1;
  688.     for(p=start; p<=end;p++){
  689.  
  690.         kr_getSubPatternByNo(&pat,&sub,p);
  691.         in_pat = kr_getSubPatData(pat,sub,INPUT,NULL);
  692.         out_pat = kr_getSubPatData(pat,sub,OUTPUT,NULL);
  693.  
  694.         FOR_ALL_INPUT_UNITS(inputUnitPtr,i){
  695.         inputUnitPtr->Out.output = inputUnitPtr->act = *in_pat++;
  696.         }
  697.   
  698.         correctMaxAct = -1.0;
  699.         wrongMaxAct   = -1.0;
  700.         correctMaxActivatedUnitPtr = NULL;
  701.         wrongMaxActivatedUnitPtr = NULL;
  702.  
  703.         FOR_ALL_HIDDEN_UNITS(hiddenUnitPtr,h) {
  704.         act = 0.0;
  705.         FOR_ALL_LINKS(hiddenUnitPtr,linkPtr) {
  706.             act += linkPtr->weight * linkPtr->to->act;
  707.         }
  708.         hiddenUnitPtr->act = act;
  709.  
  710.         if((((int)hiddenUnitPtr->bias) == ((int) *out_pat)) && 
  711.            (act >= correctMaxAct)){
  712.             correctMaxAct = act;
  713.             correctMaxActivatedUnitPtr = hiddenUnitPtr;
  714.         }
  715.         else if((((int)hiddenUnitPtr->bias)!=((int) *out_pat)) && 
  716.             (act >= wrongMaxAct)){
  717.             wrongMaxAct = act;
  718.             wrongMaxActivatedUnitPtr = hiddenUnitPtr;
  719.         }
  720.         }
  721.         if(correctMaxAct <= wrongMaxAct){
  722.         wrongClassCounter++;
  723.         mixupArray[(int) *out_pat]
  724.                   [(int)wrongMaxActivatedUnitPtr->bias].counter++;
  725.         if(j == noOfTrainingCyclesMinus1){
  726.             writeVectorToMixupArray(
  727.                        (int)correctMaxActivatedUnitPtr->bias,
  728.                        (int)wrongMaxActivatedUnitPtr->bias,
  729.                        pat,sub);
  730.         }else{ 
  731.             moveVec(correctMaxActivatedUnitPtr,learnParam1,
  732.                 wrongMaxActivatedUnitPtr,learnParam2);
  733.         }
  734.         }
  735.     } /* end: noOfTrainingCycles */
  736.     printMixupArray(j);  
  737.  
  738.     if(wrongClassCounter == 0){
  739.         continueLearning = 0;
  740.         return;
  741.     }
  742.  
  743.     if(j!=noOfTrainingCyclesMinus1){ 
  744.         initMixupArray();  
  745.         wrongClassCounter = 0;   
  746.     }
  747.     }
  748. }
  749.  
  750.  
  751.  
  752. /*****************************************************************************
  753.   FUNCTION : initLastInsertedUnitArray
  754.  
  755.   PURPOSE  : Init the array lastInsertedUnitArray. This array contains the
  756.              position of the last inserted unit. There is an entry for
  757.              every class.
  758.   NOTES    :
  759.  
  760.   UPDATE   : 5.2.93
  761. ******************************************************************************/
  762. static void initLastInsertedUnitArray(void)
  763. {
  764.     int h,bias;
  765.     struct Unit *hiddenUnitPtr=NULL,*lastUnitPtr=NULL;
  766.  
  767.     bias = (*FirstHiddenUnitPtr)->bias;
  768.     FOR_ALL_HIDDEN_UNITS(hiddenUnitPtr,h){
  769.     if(((int)(hiddenUnitPtr->bias)) == ((int)bias)) {
  770.         lastUnitPtr = hiddenUnitPtr;
  771.     }else{
  772.         lastInsertedUnitArray[(int)lastUnitPtr->bias] =
  773.         GET_UNIT_NO(lastUnitPtr);
  774.         bias = hiddenUnitPtr->bias;
  775.         lastUnitPtr = hiddenUnitPtr;
  776.     }
  777.     }
  778.     lastInsertedUnitArray[(int)lastUnitPtr->bias]=GET_UNIT_NO(lastUnitPtr);
  779.  
  780. }  
  781.  
  782.  
  783.  
  784. /*****************************************************************************
  785.   FUNCTION : dlvq_setPointers
  786.  
  787.   PURPOSE  : Calculates the beginning of the input, hidden, output
  788.              units in the topo_ptr_array.
  789.   NOTES    :
  790.  
  791.   UPDATE   : 5.2.93
  792. ******************************************************************************/
  793. krui_err dlvq_setPointers(void)
  794. {
  795.     FirstInputUnitPtr   = (struct Unit **)(&topo_ptr_array[1]);
  796.     if(*(FirstInputUnitPtr-1)!=NULL) CC_ERROR(KRERR_CC_ERROR1);
  797.     FirstHiddenUnitPtr  = FirstInputUnitPtr  + NoOfInputUnits  + 1;
  798.     if(*(FirstHiddenUnitPtr-1)!=NULL) CC_ERROR(KRERR_CC_ERROR1);
  799.     FirstOutputUnitPtr  = FirstHiddenUnitPtr + NoOfHiddenUnits + 1;
  800.     if(*(FirstOutputUnitPtr-1)!=NULL) CC_ERROR(KRERR_CC_ERROR1);
  801.     return(KRERR_NO_ERROR);
  802. }
  803.  
  804.  
  805.  
  806. /*****************************************************************************
  807.   FUNCTION : generateMissingClassHiddenUnits
  808.  
  809.   PURPOSE  : If all hidden units of a class are removed, this functions 
  810.              generates a new first hidden unit. 
  811.   NOTES    :
  812.  
  813.   UPDATE   : 5.2.93
  814. ******************************************************************************/
  815. void generateMissingClassHiddenUnits(int *generatedNewUnit)
  816. {
  817.     struct Unit *hiddenUnitPtr;
  818.     int i,h;
  819.  
  820.     *generatedNewUnit = 0;
  821.  
  822.     for(i=0;i<noOfClasses;i++){
  823.     lastInsertedUnitArray[i] = 0;
  824.     }
  825.     FOR_ALL_HIDDEN_UNITS(hiddenUnitPtr,h){
  826.     lastInsertedUnitArray[(int)hiddenUnitPtr->bias] = 1;
  827.     }
  828.     for(i=0;i<noOfClasses;i++){
  829.     if(lastInsertedUnitArray[i] == 0) {
  830.         (void)insertFirstUnit(&hiddenUnitPtr);
  831.         initFirstUnit(hiddenUnitPtr,i);
  832.         *generatedNewUnit = 1;
  833.     }else{
  834.         lastInsertedUnitArray[i] = 0;
  835.     } 
  836.     }
  837. }
  838.  
  839.  
  840.  
  841. /*****************************************************************************
  842.   FUNCTION : insertFirstUnit
  843.  
  844.   PURPOSE  : Inserts the first hidden units to the net. For every class one
  845.              unit.
  846.   NOTES    :
  847.  
  848.   UPDATE   : 5.2.93
  849. ******************************************************************************/
  850. static krui_err insertFirstUnit(struct Unit **hiddenUnitPtr)
  851. {
  852.     int hiddenUnit=0;
  853.     struct Unit *inputUnitPtr;
  854.  
  855.     hiddenUnit = KernelErrorCode = krui_createDefaultUnit(); 
  856.     if(KernelErrorCode < 0) {
  857.     ERROR_CHECK;
  858.     }
  859.  
  860.     KernelErrorCode = krui_setUnitTType(hiddenUnit,HIDDEN);  
  861.     ERROR_CHECK;
  862.  
  863.     KernelErrorCode = krui_setUnitActFunc(hiddenUnit,"Act_Identity");
  864.     ERROR_CHECK;
  865.  
  866.     *hiddenUnitPtr = kr_getUnitPtr(hiddenUnit);
  867.     KernelErrorCode = krui_setCurrentUnit(hiddenUnit);
  868.     ERROR_CHECK;
  869.  
  870.     /* generate links between hidden unit and input units */
  871.     FOR_ALL_UNITS(inputUnitPtr) {
  872.     if(IS_INPUT_UNIT(inputUnitPtr) && UNIT_IN_USE(inputUnitPtr)){
  873.         KernelErrorCode = krui_createLink(GET_UNIT_NO(inputUnitPtr),0.0);
  874.         ERROR_CHECK;
  875.     }
  876.     }
  877.  
  878.     /* generate a link between the output unit and the hidden unit */
  879.     KernelErrorCode = krui_setCurrentUnit(GET_UNIT_NO(*FirstOutputUnitPtr));
  880.     ERROR_CHECK;
  881.     KernelErrorCode = krui_createLink(hiddenUnit,1.0); 
  882.     ERROR_CHECK;
  883.     return(KRERR_NO_ERROR);
  884. }
  885.  
  886.  
  887.  
  888. /*****************************************************************************
  889.   FUNCTION : allocArrays
  890.  
  891.   PURPOSE  :
  892.   NOTES    :
  893.  
  894.   UPDATE   : 5.2.93
  895. ******************************************************************************/
  896. void allocArrays(void)
  897. {
  898.     allocMixupArray();
  899.     allocLastInsertedUnitArray();
  900. }
  901.  
  902.  
  903.  
  904. /*****************************************************************************
  905.   FUNCTION : generateTmpTopoPtrArray
  906.  
  907.   PURPOSE  : Generates a topo_ptr_array for local use.
  908.   NOTES    :
  909.  
  910.   UPDATE   : 5.2.93
  911. ******************************************************************************/
  912. static void generateTmpTopoPtrArray(void)
  913. {
  914.     struct Unit *unitPtr;
  915.     TopoPtrArray tmp_array;
  916.  
  917.     if(topo_ptr_array != NULL) {
  918.     free(topo_ptr_array);
  919.     }
  920.  
  921.     tmp_array = 
  922.     topo_ptr_array = 
  923.         (struct Unit **)calloc(NoOfInputUnits+5,sizeof(struct Unit *));
  924.  
  925.     *tmp_array = NULL;
  926.     tmp_array++;
  927.     FOR_ALL_UNITS(unitPtr){
  928.     if(IS_INPUT_UNIT(unitPtr) && UNIT_IN_USE(unitPtr)){
  929.         *tmp_array = unitPtr;
  930.         tmp_array++;
  931.     }
  932.     }
  933.     *tmp_array = NULL;
  934.     tmp_array++;
  935.     *tmp_array = NULL;
  936.     tmp_array++;
  937.     FOR_ALL_UNITS(unitPtr){
  938.     if(IS_OUTPUT_UNIT(unitPtr) && UNIT_IN_USE(unitPtr)){
  939.         *tmp_array = unitPtr;
  940.         tmp_array++;
  941.     }
  942.     }
  943.     *tmp_array = NULL;
  944. }
  945.  
  946.  
  947.  
  948. /*****************************************************************************
  949.   FUNCTION : freeTmpTopoPtrArray
  950.  
  951.   PURPOSE  : Frees the storage of the temporary "topo_ptr_array".
  952.   NOTES    :
  953.  
  954.   UPDATE   : 5.2.93
  955. ******************************************************************************/
  956. static void freeTmpTopoPtrArray(void)
  957. {
  958.     free(topo_ptr_array);
  959.     topo_ptr_array = NULL;
  960. }
  961.  
  962.  
  963.  
  964. /*****************************************************************************
  965.   FUNCTION : LEARN_DLVQ
  966.  
  967.   PURPOSE  : The main learn routine of DLVQ
  968.   NOTES    :
  969.  
  970.   UPDATE   : 5.2.93
  971. ******************************************************************************/
  972. krui_err LEARN_DLVQ(int startPattern, int endPattern, float *ParameterInArray,
  973.             int NoOfInParams, float **ParameterOutArray, 
  974.             int *NoOfOutParams)
  975. {
  976.     static int cycleCounter=0,noOfTrainingCycles=0;
  977.     struct Unit  *unitPtr,*hiddenUnitPtr;
  978.     int i,d1,d2,d3,noOfLinks,generatedNewUnit;
  979.     static float learnParam1=0.03,learnParam2=0.03;
  980.     static float OutParameter[1];
  981.  
  982.     *NoOfOutParams = 1;
  983.     *ParameterOutArray = OutParameter;
  984.  
  985.     if(cc_allButtonIsPressed) {
  986.     continueLearning = 1;
  987.     cycleCounter = 0;
  988.     wrongClassCounter = 0;
  989.     NoOfInputUnits = NoOfHiddenUnits = NoOfOutputUnits = 0;
  990.     FOR_ALL_UNITS(unitPtr) {
  991.         if(IS_INPUT_UNIT(unitPtr) && UNIT_IN_USE(unitPtr)) {
  992.         NoOfInputUnits++;
  993.         }
  994.         if(IS_HIDDEN_UNIT(unitPtr) && UNIT_IN_USE(unitPtr)) {
  995.         NoOfHiddenUnits++;
  996.         }
  997.         if(IS_OUTPUT_UNIT(unitPtr) && UNIT_IN_USE(unitPtr)) {
  998.         NoOfOutputUnits++;
  999.         }
  1000.     }
  1001.     if(NoOfOutputUnits != 1){
  1002.         return(DLVQ_ERROR3); /* Wrong no. of output units */
  1003.     }
  1004.  
  1005.     learnParam1 = ParameterInArray[0];
  1006.     learnParam2 = ParameterInArray[1];
  1007.     noOfTrainingCycles = (int)ParameterInArray[2];
  1008.     }
  1009.   
  1010.  
  1011.     if(newPatternsLoaded){
  1012.     newPatternsLoaded = 0;
  1013.     KernelErrorCode = getNoOfClasses(startPattern,endPattern);
  1014.     ERROR_CHECK;
  1015.     normPatterns(startPattern,endPattern);
  1016.     allocInitialUnitArray();
  1017.     initInitialUnitArray(startPattern,endPattern);
  1018.     }
  1019.  
  1020.     if(cc_allButtonIsPressed && (NoOfHiddenUnits == 0)){ /* First time */
  1021.     allocArrays();
  1022.     generateTmpTopoPtrArray();
  1023.     KernelErrorCode = dlvq_setPointers();
  1024.     ERROR_CHECK;
  1025.     KernelErrorCode = deleteAllLinksOfTheOutputUnit();
  1026.     ERROR_CHECK;
  1027.     for(i=0;i<noOfClasses;i++) {
  1028.         KernelErrorCode = insertFirstUnit(&hiddenUnitPtr);
  1029.         ERROR_CHECK;
  1030.         initFirstUnit(hiddenUnitPtr,i);
  1031.     }
  1032.     freeTmpTopoPtrArray();
  1033.     KernelErrorCode = kr_topoSort(TOPOLOGICAL_FF);
  1034.     ERROR_CHECK;     
  1035.     KernelErrorCode = dlvq_setPointers();
  1036.     ERROR_CHECK; 
  1037.  
  1038.     sortHiddenUnitsByClasses(0,noOfClasses-1);
  1039.     calculateUnitXYPos();    
  1040.     initLastInsertedUnitArray();
  1041.  
  1042.     NetModified = FALSE;
  1043.     LearnFuncHasChanged = FALSE;
  1044.     }else if(cc_allButtonIsPressed && (NoOfHiddenUnits != 0)) { 
  1045.  
  1046.     /* Continue learning */
  1047.     if(NetModified || LearnFuncHasChanged){
  1048.         allocArrays();
  1049.         KernelErrorCode = kr_topoSort(TOPOLOGICAL_FF);
  1050.         ERROR_CHECK;    
  1051.         KernelErrorCode = dlvq_setPointers();
  1052.         ERROR_CHECK; 
  1053.         krui_getNetInfo(&d1,&noOfLinks,&d2,&d3);
  1054.         if(noOfLinks != NoOfInputUnits*NoOfHiddenUnits + NoOfHiddenUnits){
  1055.         return(DLVQ_ERROR4); /* the network has a wrong topology */
  1056.         }
  1057.  
  1058.         generateMissingClassHiddenUnits(&generatedNewUnit);
  1059.         if(generatedNewUnit) {
  1060.         KernelErrorCode = kr_topoSort(TOPOLOGICAL_FF);
  1061.         ERROR_CHECK;
  1062.         KernelErrorCode = dlvq_setPointers();
  1063.         ERROR_CHECK; 
  1064.         }
  1065.         NetModified = FALSE;
  1066.         LearnFuncHasChanged = FALSE;
  1067.     }
  1068.       
  1069.     /* even if the net is not modified you have to do the following
  1070.        steps for security. 
  1071.        */  
  1072.     sortHiddenUnitsByClasses(0,NoOfHiddenUnits-1);
  1073.     calculateUnitXYPos();         
  1074.     initLastInsertedUnitArray();
  1075.     }  
  1076.  
  1077.     if(cc_allButtonIsPressed){
  1078.     oldNoOfClasses = noOfClasses;
  1079.     cc_allButtonIsPressed = 0;
  1080.     }
  1081.  
  1082.     if(continueLearning){
  1083.     initMixupArray();
  1084.     dlvq_trainNet(noOfTrainingCycles,startPattern,endPattern,
  1085.               learnParam1,learnParam2);
  1086.     NET_ERROR(OutParameter) = wrongClassCounter;
  1087.     if((cycleCounter<(dlvq_numberOfLearnCycles-1)) &&
  1088.        (wrongClassCounter != 0)){ 
  1089.         /*do not insert new hidden units by the last path through the net*/
  1090.         wrongClassCounter = 0;
  1091.         cycleCounter++; 
  1092.         KernelErrorCode = insertNewUnits();
  1093.         ERROR_CHECK;
  1094.         KernelErrorCode = kr_topoSort(TOPOLOGICAL_FF);
  1095.         ERROR_CHECK;
  1096.         KernelErrorCode = dlvq_setPointers();
  1097.         ERROR_CHECK; 
  1098.     }
  1099.     } 
  1100.     return(KRERR_NO_ERROR);
  1101. }
  1102.  
  1103.  
  1104.